home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / et / et3_0-a1.lha / et3 / src / StyledText.C < prev    next >
C/C++ Source or Header  |  1992-08-20  |  12KB  |  484 lines
  1. #ifdef __GNUG__
  2. #pragma implementation
  3. #endif
  4.  
  5. #include "StyledText.h"
  6.  
  7. #include "Class.h"
  8. #include "WindowSystem.h"
  9. #include "RunArray.h"
  10. #include "Mark.h"
  11. #include "OrdColl.h"
  12. #include "Error.h"
  13. #include "Invariant.h"
  14. #include "TextReader.h"
  15. #include "Math.h"
  16.  
  17. extern "C" void REP(StyledText *st);
  18.  
  19. void REP(StyledText *st)
  20. {
  21.     st->Dump();
  22. }
  23.  
  24. InvariantChecker(StyledText);
  25.  
  26. //----- colors for BuildStylesFromString --------------------------------------
  27.  
  28. Ink *red, *green, *blue;
  29.  
  30. //----- StyledText -------------------------------------------------------------
  31.  
  32. NewMetaImpl(StyledText,GapText, (TP(charStyles), TP(paraStyles), 
  33.                TP(styleHere), T(applyStyleHere)));    
  34.  
  35. static TextChanges changeRec;
  36.  
  37. StyledText::StyledText(int size, Font *fd, TxtParaAlign al) : GapText(size, fd)
  38. {
  39.     InitStyles(new_CharStyle(fd), new_ParaStyle(al));
  40. }
  41.  
  42. StyledText::StyledText(byte *buf, int len, Font *fd, TxtParaAlign al)  
  43.                              : GapText(buf, len, fd)
  44. {
  45.     InitStyles(new_CharStyle(fd), new_ParaStyle(al));
  46. }
  47.  
  48. StyledText::StyledText(Font *fd, char* va_(fmt), ...)
  49. {
  50.     char *buf;
  51.  
  52.     va_list ap;
  53.     va_start(ap,va_(fmt));
  54.     buf= strvprintf(va_(fmt), ap);
  55.     va_end(ap);
  56.     
  57.     InitStyles(new_CharStyle(fd), new_ParaStyle());
  58.     BuildStylesFromString(new_CharStyle(fd), buf);
  59.     SafeDelete(buf);
  60. }
  61.  
  62. StyledText::~StyledText()
  63. {
  64.     SafeDelete(charStyles);
  65.     SafeDelete(paraStyles);
  66. }
  67.  
  68. void StyledText::InitNew()
  69. {
  70.     GapText::InitNew();
  71.     InitStyles(new_CharStyle(gSysFont), new_ParaStyle());
  72. }
  73.  
  74. void StyledText::InitStyles(CharStyle *cs, ParaStyle *ps)
  75. {
  76.     charStyles= new RunArray;
  77.     paraStyles= new RunArray;
  78.     applyStyleHere= FALSE;
  79.         
  80.     paraStyles->Insert(ps, 0, 0, Size());
  81.     charStyles->Insert(cs, 0, 0, Size());
  82. }
  83.  
  84. int StyledText::GetNextFontChange(int at, CharStyle *&sp)
  85. { 
  86.     int start, end, size, lenat;
  87.     at= Math::Range(0, Size()-1, at);
  88.     sp= (CharStyle*)charStyles->RunAt(at, &start, &end, &size, &lenat);
  89.     return at+lenat;
  90. }
  91.  
  92. void StyledText::ReplaceWithStr(byte *str,int len)
  93. {
  94.     GapText::ReplaceWithStr(str, len);
  95.     SafeDelete(charStyles);
  96.     SafeDelete(paraStyles);
  97.     InitStyles(new_CharStyle(GetFont()), new_ParaStyle());   
  98. }
  99.  
  100. void StyledText::Cut(int from, int to)
  101. {
  102.     int start, end, size, lenat;
  103.     CharStyle *sp= (CharStyle*)charStyles->RunAt(from, &start, &end, &size, &lenat);
  104.     applyStyleHere= FALSE;
  105.     if (start == from && size <= to - from) {
  106.     applyStyleHere= TRUE;
  107.     styleHere= sp;
  108.     }
  109.     GapText::Cut(from, to);
  110. }
  111.  
  112. void StyledText::Dump()
  113. {
  114.     RunArrayIter next(paraStyles);
  115.     int start, end, size, i;
  116.     
  117.     fprintf(stderr, "DUMP\n");
  118.     fprintf(stderr, "Runs\n");
  119.     for (i= 0; next.Run(&start, &end, &size) != 0; i++) {
  120.     fprintf(stderr, "%d ", end);
  121.     if (!IsBreak(CharAt(end-1)))
  122.         fprintf(stderr, "!");
  123.     }
  124.     fprintf(stderr, "\n");
  125. }
  126.  
  127. void StyledText::CheckInvariant()
  128. {
  129.     if (GetAssertLevel() > 10)
  130.     return;
  131.  
  132.     RunArrayIter next(paraStyles);
  133.     int start, end, size, i;
  134.     
  135.     if (paraStyles->Size() != Size()) {
  136.     fprintf(stderr, "!!!StyledText Invariant: paraStyles: size differs! %d %d\n", paraStyles->Size(), Size());
  137.     Dump();
  138.     }
  139.     if (charStyles->Size() != Size()) {
  140.     fprintf(stderr, "!!!StyledText Invariant: charStyles: size differs! %d %d\n", paraStyles->Size(), Size());
  141.     Dump();
  142.     }
  143.     for (i= 0; next.Run(&start, &end, &size) != 0; i++) {
  144.     if (!IsBreak(CharAt(end-1)) && end < Size()) {
  145.         fprintf(stderr, "!!!StyledText Invariant: no paragraph at %d\n", end-1);
  146.         Dump();
  147.     }
  148.     }
  149. }
  150.  
  151. void StyledText::CutParaStyles(int from, int to, int sz)
  152. {
  153.     int pfl, pfr;
  154.     
  155.     GetParaRange(from, &pfl, &pfr);
  156.     paraStyles->Cut(from, to);
  157.     paraStyles->ChangeRunSize(from, sz, eRARight);
  158.     if(pfl < Size()) {
  159.     ParaStyle *ps= GetParaStyle(pfl);
  160.     paraStyles->Insert(ps, from, pfr, pfr-from);
  161.     }
  162. }
  163.  
  164. void StyledText::ReplaceRange(int from, int to, Text* src, int sfrom, int sto)
  165. {
  166.     AssertInvariant(StyledText);
  167.     int sz= sto-sfrom;
  168.     
  169.     DoDelayChanges dc(this);
  170.     
  171.     GapText::ReplaceRange(from, to, src, sfrom, sto);
  172.     if (src->IsKindOf(StyledText)) { 
  173.     StyledText *st= (StyledText*) src;
  174.     charStyles->ReplaceRange(from, to, st->charStyles, sfrom, sto);
  175.     PasteParaStyles(from, to, st->paraStyles, sfrom, sto);
  176.     return;
  177.     }
  178.     if (from != to) 
  179.     CutStyles(from, to, sz);
  180.     else
  181.     paraStyles->ChangeRunSize(from, sz, eRARight);
  182.     
  183.     if (applyStyleHere && sz) { // insert new run with styleHere
  184.     charStyles->Insert(styleHere, from, from, sz);
  185.     applyStyleHere= FALSE;
  186.     } else 
  187.     AddChars(from, sz);
  188. }
  189.  
  190. void StyledText::CutStyles(int from, int to, int sz)
  191. {
  192.     int start, end, size, lenat;
  193.     CharStyle *sp= (CharStyle*)charStyles->RunAt(from, &start, &end, &size, &lenat);
  194.     if (start == from && size <= to - from) {
  195.     applyStyleHere= TRUE;
  196.     styleHere= sp;
  197.     }
  198.     CutParaStyles(from, to, sz);
  199.     charStyles->Cut(from, to);
  200. }
  201.  
  202. void StyledText::PasteParaStyles(int from, int to, RunArray *pr, int sfrom, int sto)
  203. {
  204.     int pfl, pfr, ptl, ptr, sz= sto-sfrom; 
  205.     ParaStyle *ps;
  206.     
  207.     paraStyles->ReplaceRange(from, to, pr, sfrom, sto);
  208.     
  209.     GetParaRange(from, &pfl, &pfr);
  210.     GetParaRange(from+sz, &ptl, &ptr);
  211.     
  212.     if(pfl == ptl) {
  213.     ps= GetParaStyle(from+sz);
  214.     paraStyles->Insert(ps, from, from+sz, sz);
  215.     } else {
  216.     ps= GetParaStyle(pfl);
  217.     paraStyles->Insert(ps, from, pfr, pfr-from);
  218.     ps= GetParaStyle(ptl);
  219.     paraStyles->Insert(ps, from+sz, ptr, ptr-from-sz);
  220.     }
  221. }
  222.  
  223. void StyledText::AddChars(int at, int sz)
  224. {
  225.     RArrayGrowDir g= eRALeft;
  226.     if (IsParaStart(at))
  227.     g= eRARight;
  228.     charStyles->ChangeRunSize(at, sz, g);
  229. }
  230.  
  231. void StyledText::SetFStringVL(char *fmt, va_list ap)
  232. {
  233.     char *buf= strvprintf(fmt, ap);
  234.     
  235.     CharStyle *st= GetCharStyle(0);
  236.     BuildStylesFromString(st, buf);
  237.     SafeDelete(buf);
  238. }
  239.  
  240. OStream &StyledText::PrintOn(OStream &s) 
  241. {
  242.     AssertInvariant(StyledText);
  243.     GapText::PrintOn(s);
  244.     return s << charStyles SP << paraStyles SP;
  245. }
  246.  
  247. IStream &StyledText::ReadFrom(IStream &s) 
  248. {
  249.     AssertInvariant(StyledText);
  250.     GapText::ReadFrom(s);
  251.     s >> charStyles >> paraStyles;
  252.     return s;
  253. }
  254.  
  255. IStream& StyledText::ReadFromAsPureText(IStream &s, long sizeHint)
  256. {
  257.     GapText::ReadFromAsPureText(s, sizeHint);
  258.     SafeDelete(paraStyles);
  259.     SafeDelete(charStyles);
  260.     InitStyles(new_CharStyle(GapText::GetFont(0)), new_ParaStyle());
  261.     return s;
  262. }
  263.  
  264. void StyledText::SetCharStyle(TxtCharProp what, int from, int to, const CharStyleSpec &st)
  265. {
  266.     int start, end, size;
  267.  
  268.     if (from == to) {
  269.     CharStyle *sp= applyStyleHere ? styleHere : GetCharStyle(Math::Max(0, from-1));
  270.     applyStyleHere= TRUE;
  271.     styleHere= gCharStyles->ChangeProperty(sp, what, st);
  272.     } else {
  273.     CharStyle **spp;
  274.     RunArray newStyles(2); 
  275.     charStyles->Copy(&newStyles, from, to);
  276.     RunArrayIter next(&newStyles);
  277.     while (spp= (CharStyle**)next.RunPtr(&start, &end, &size)) 
  278.         *spp= gCharStyles->ChangeProperty(*spp, what, st);
  279.     charStyles->Paste(&newStyles, from, to);
  280.     
  281.     GetMarkList()->RangeChanged(from, to - from);
  282.     Send(cIdNone, eTextChangedRange, changeRec(from, to));     
  283.     }
  284. }
  285.   
  286. void StyledText::BuildStylesFromString(CharStyle *cs, char *buf)
  287. {
  288.     TextReader *reader= new TextReader(this, cs, new_ParaStyle());
  289.  
  290.     if (gColor) {
  291.     red= new_RGBColor(255, 0, 0);
  292.     green= new_RGBColor(0, 255, 0);
  293.     blue= new_RGBColor(0, 0, 255);
  294.     }
  295.  
  296.     for (byte *p= (byte*)buf; *p != '\0'; p++) {
  297.     if (*p == '@') {
  298.         if (*(p+1) && strchr("OUSBIPrgbx[]|_*<>+-^v", *(p+1))) {
  299.         p++;
  300.         switch (*p) {
  301.         case 'P':
  302.             reader->SetFace(eFacePlain);
  303.             break;
  304.         case 'O':
  305.             reader->ToggleFace(eFaceOutline);
  306.             break;
  307.         case 'S':
  308.             reader->ToggleFace(eFaceShadow);
  309.             break;
  310.         case 'U':
  311.             reader->ToggleFace(eFaceUnderline);
  312.             break;
  313.         case 'B':
  314.             reader->ToggleFace(eFaceBold);
  315.             break;
  316.         case 'I':
  317.             reader->ToggleFace(eFaceItalic);
  318.             break;
  319.         case 'x':
  320.             reader->SetInk(gInkBlack);
  321.             break;
  322.         case 'r':
  323.             if (gColor)
  324.             reader->SetInk(red);
  325.             break;
  326.         case 'g':
  327.             if (gColor)
  328.             reader->SetInk(green);
  329.             break;
  330.         case 'b':
  331.             if (gColor)
  332.             reader->SetInk(blue);
  333.             break;
  334.         case '+':
  335.             reader->SetSize(reader->GetSize()+4);
  336.             break;
  337.         case '-':
  338.             reader->SetSize(reader->GetSize()-4);
  339.             break;
  340.         case '[':
  341.             reader->SetParaProp(eTxtPAlign, eTxtParaLeft);
  342.             break;
  343.         case ']':
  344.             reader->SetParaProp(eTxtPAlign, eTxtParaRight);
  345.             break;
  346.         case '|':
  347.             reader->SetParaProp(eTxtPAlign, eTxtParaCenter);
  348.             break;
  349.         case '_':
  350.             reader->SetParaProp(eTxtPAlign, eTxtParaJustified);
  351.             break;
  352.         case '<':
  353.             reader->SetParaProp(eTxtPLeft, 0);
  354.             break;
  355.         case '>':
  356.             reader->SetParaProp(eTxtPLeft, 20);
  357.             break;
  358.         case '^':
  359.             reader->SetParaProp(eTxtPSpaceBefore, 20);
  360.             break;
  361.         case 'v':
  362.             reader->SetParaProp(eTxtPSpaceBefore, 0);
  363.             break;
  364.         }
  365.          } else { 
  366.          p++;
  367.          if (!*p)
  368.              break;
  369.          reader->Append(*p);
  370.          }
  371.     } else 
  372.         reader->Append(*p);
  373.     }
  374.     reader->Flush();
  375.     SafeDelete(reader);
  376.     CheckInvariant(); 
  377. }
  378.  
  379. CharStyle *StyledText::GetCharStyle(int at)
  380. {
  381.     int d; // ???? -1
  382.     at= Math::Range(0, Size()-1, at);
  383.     return (CharStyle*) charStyles->RunAt(at, &d, &d, &d, &d);
  384. }
  385.  
  386. void StyledText::ReplaceCharStyles(RunArray *st, int from, int to)
  387. {
  388.     if (to-from != st->Size())
  389.     Error("ReplaceCharStyle", "RunArray does not match text");
  390.     charStyles->Paste(st, from, to);
  391.     
  392.     GetMarkList()->RangeChanged(from, to-from);
  393.     Send(cIdNone, eTextChangedRange, changeRec(from, to));     
  394. }
  395.  
  396. void StyledText::ReplaceParaStyles(RunArray *st, int from, int to)
  397. {
  398.     if (to-from != st->Size())
  399.     Error("ReplaceParaStyles", "RunArray does not match text");
  400.     paraStyles->Paste(st, from, to);
  401.     
  402.     GetMarkList()->RangeChanged(from, to-from);
  403.     Send(cIdNone, eTextChangedRange, changeRec(from, to));     
  404. }
  405.  
  406. void StyledText::ResetCurrentCharStyle()
  407. {
  408.     if (End() != 0)
  409.     applyStyleHere= FALSE;
  410. }
  411.  
  412. CharStyle *StyledText::GetCurrentCharStyle()
  413. {
  414.     if (applyStyleHere)
  415.     return styleHere;
  416.     return 0;    
  417. }
  418.  
  419. RunArray *StyledText::GetCharStyles()
  420. {
  421.     return charStyles; 
  422. }
  423.  
  424. RunArray *StyledText::GetParaStyles()
  425. {
  426.     return paraStyles; 
  427. }
  428.  
  429. RunArray *StyledText::SetCharStyles(RunArray *st)
  430. {
  431.     if (st->Size() != Size())
  432.     Error("StyledText", "StyleArray does not correspond to the text");
  433.  
  434.     RunArray *old= charStyles;
  435.     charStyles= st;
  436.     return old;
  437. }
  438.  
  439. RunArray *StyledText::SetParaStyles(RunArray *st)
  440. {
  441.     if (st->Size() != Size())
  442.     Error("StyledText", "StyleArray does not correspond to the text");
  443.  
  444.     RunArray *old= paraStyles;
  445.     paraStyles= st;
  446.     return old;
  447. }
  448.  
  449. void StyledText::SetParaStyle(TxtParaProp what, int from, int to, const ParaDesc &pd)
  450. {
  451.     int pfl, ptr, dd;   // paragraph ranges
  452.     int start, end, size;
  453.  
  454.     // find start and end of paragraphs
  455.     GetParaRange(from, &pfl, &dd);
  456.     if (to == from)
  457.     ptr= dd;
  458.     else if (IsPara((*this)[to-1]))
  459.     ptr= to;
  460.     else
  461.     GetParaRange(to, &dd, &ptr);
  462.     
  463.     ParaStyle **spp;
  464.     RunArray newStyles(2);
  465.     paraStyles->Copy(&newStyles, pfl, ptr);
  466.     RunArrayIter next(&newStyles);
  467.     while (spp= (ParaStyle**)next.RunPtr(&start, &end, &size)) 
  468.     *spp= gParaStyles->ChangeProperty(*spp, what, pd);
  469.     paraStyles->Paste(&newStyles, pfl, ptr);
  470.     
  471.     GetMarkList()->RangeChanged(pfl, ptr-pfl);
  472.     bool pagination= ((what & eTxtPNoBreak) == eTxtPNoBreak)
  473.              || ((what & eTxtPKeepNext) == eTxtPKeepNext);
  474.     Send(cIdNone, eTextChangedRange, changeRec(pfl, ptr, 0, pagination));     
  475. }
  476.  
  477. ParaStyle *StyledText::GetParaStyle(int at)
  478. {
  479.     int d; 
  480.     at= Math::Range(0, Size()-1, at);
  481.     return (ParaStyle*) paraStyles->RunAt(at, &d, &d, &d, &d);
  482. }
  483.  
  484.